using System;
using System.IO;
using Gtk;
using Gdk;
using System.Diagnostics;
using System.Collections;

namespace animeshell
{
	
	
	public class Traitement
	{
		//*****************************************************************************
		// Variables
		//*****************************************************************************
		private string m_TreeviewSelect = null;
		private string m_TreeviewSelectdvd = null;
		private int m_TreeviewSelectID = -1;
		private string m_Dossier = null;
		private string m_Conf = null;
		private string m_Confsave = null;
		private string m_rc = null;
		private string [] m_Pref = null;
		private int m_ID = 1;
		
		//**********************************************************
		// Essais! ^_^
		//**********************************************************
		private ArrayList m_DonneArray;
		
		public Traitement()
		{
			m_Pref = new string[2];
			m_DonneArray = new ArrayList();
			//MesEntre = new ArrayList();
			//MesEntre.Add(new Entree(1,"Nom", 'd', 32, "un commentaire"));
		}
		
		//*****************************************************************************
		// Propriétés {get}{set}
		//*****************************************************************************
		public int TreeviewSelectID
		{
			get
			{
				return m_TreeviewSelectID;
			}
			set
			{
				if (value > -1)
					m_TreeviewSelectID = value;
			}
		}
		
		public string TreeviewSelect
		{
			get
			{
				return m_TreeviewSelect;
			}
			set
			{
				if (value != "")
					m_TreeviewSelect = value;
			}
		}
		
		public string TreeviewSelectdvd
		{
			get
			{
				return m_TreeviewSelectdvd;
			}
			set
			{
				if (value != "")
					m_TreeviewSelectdvd = value;
			}
		}
		
		public string Dossier
		{
			get
			{
				return m_Dossier;
			}
			set
			{
				if (value != "")
					m_Dossier = value;
			}
		}
		
		public string Conf
		{
			get
			{
				return m_Conf;
			}
			set
			{
				if (value != "")
					m_Conf = value;
			}
		}
		
		public string Confsave
		{
			get
			{
				return m_Confsave;
			}
			set
			{
				if (value != "")
					m_Confsave = value;
			}
		}
		
		public string rc
		{
			get
			{
				return m_rc;
			}
			set
			{
				if (value != "")
					m_rc = value;
			}
		}
		
		public string[] Pref
		{
			get
			{
				return m_Pref;
			}
		}
		
		public int ID
		{
			get
			{
				return m_ID;
			}
			set
			{
				if (value > 0)
					m_ID = value;
			}
		}
		
			
		//**********************************************************************
		// Selectionne l'environnement et configure les dossiers et fichiers
		//**********************************************************************
		public bool SelectEnv()
		{
			//Variable
			string CurrentOS = null;
			bool Retour = false;
			OperatingSystem os = Environment.OSVersion;
			CurrentOS = os.ToString();
			
			if (CurrentOS[0] == 'M')
			{
				// Windows
				m_Dossier = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)+"\\animeshell";
				m_Conf = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)+"\\animeshell\\as.db";
				m_Confsave = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)+"\\animeshell\\as.db~";
				m_rc = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)+"\\animeshell\\animeshellrc";
				Retour = true;
			}
			else
			{
				
				if (CurrentOS[0] == 'U')
				{
					// Linux
					m_Dossier = "/home/"+Environment.UserName.ToString()+"/.animeshell/";
					m_Conf = "/home/"+Environment.UserName.ToString()+"/.animeshell/as.db";
					m_Confsave = "/home/"+Environment.UserName.ToString()+"/.animeshell/as.db~";
					m_rc = "/home/"+Environment.UserName.ToString()+"/.animeshell/animeshellrc";
					Retour = true;
				}
				else
				{
					// *BSD, Sun??? => erreur
					Retour = false;
				}
			}
			return Retour;
			
		}
		
		//**********************************************************************
		// Crée les fichiers et dossiers s'ils sont inexistants
		//**********************************************************************
		public bool CompleteConf()
		{
			// Variables
			FileStream fs = null;
			bool Retour = false;
			StreamWriter sw = null;
			try
			{
				// Création des fichiers et dossiers
				if (!Directory.Exists(Dossier))
					Directory.CreateDirectory(Dossier);
				if (!File.Exists(Conf))
					fs = File.Create(Conf);
				if (!File.Exists(rc))
				{
					sw = new StreamWriter(rc, false);
					sw.WriteLine("aucun");
					sw.WriteLine("http://anidb.info/");
					sw.Close();
				}
				Retour = true;
			}
			catch
			{
				Retour = false;	
			}
			finally
			{
				// Fermeture du filestream
				if (fs != null)
					fs.Close();
			}
			
			return Retour;
		}
		
		//**********************************************************************
		// Lecture des données pour l'Arraylist
		//**********************************************************************
		public bool Lecture_Initiale()
		{
			// Variables
			StreamReader sr = null;
			
			string sID = null;
			string Nom = null;
			string dvd = null;
			string Commentaire = null;
			string sType = null;
			int Local_ID = 0;
			char cType = ' ';
			
			bool Retour = false;
			
			// Traitement
			try
			{
				sr = new StreamReader(Conf);
				
				while ((sID = sr.ReadLine()) != null)
				{
					// Lecture d'une entrée à la fois
					Nom = sr.ReadLine();
					dvd = sr.ReadLine();
					sType = sr.ReadLine();
					Commentaire = sr.ReadLine();
					
					Local_ID = Convert.ToInt32(sID);
					cType = Convert.ToChar(sType);
					
					// Ajout à l'ArrayList
					m_DonneArray.Add(new Entree(Local_ID, Nom, cType, dvd, Commentaire));
					
				}
				ID = Local_ID;
				ID++;
				/*
				MessageDialog md = new MessageDialog (null,DialogFlags.DestroyWithParent,
				                                         MessageType.Error,ButtonsType.Close,
				                                         m_ID.ToString());
				md.Run();
				md.Destroy();
				*/
				Retour = true;
			}
			catch
			{
				Retour = false;
			}
			finally
			{
				if (sr != null)
					sr.Close();
			}
			
			// Retour de la fonction
			return Retour;
		}
		
		//**************************************************************************
		// Lecture des données 
		//**************************************************************************
		public bool Affichage_Treeview(ref Gtk.ListStore AnimeDB)
		{
			// Variables
			bool Retour = false;
			Gdk.Pixbuf ImgType;
			
			// Traitement
			try
			{
				AnimeDB.Clear();
				
				foreach (Entree Entre_Temporaire in m_DonneArray)
				{
					switch (Entre_Temporaire.m_TypeDonne)
					{
						case 'd':	ImgType = Pixbuf.LoadFromResource("dvd_unmount.png");
									break;
						case 'c':	ImgType = Pixbuf.LoadFromResource("cdrom_unmount.png");
									break;
						case 'h':	ImgType = Pixbuf.LoadFromResource("folder_video.png");
									break;
						default :	ImgType = Pixbuf.LoadFromResource("dvd_unmount.png");
									break;
					}
					
					AnimeDB.AppendValues(
					                         Entre_Temporaire.m_ID,
					                         "  "+Entre_Temporaire.m_Nom+"  ",
					                         ImgType,
					                         "  "+Entre_Temporaire.m_NoEntre
					                         );
				}
				Retour = true;
			}
			catch
			{
				Retour = false;
			}
			
			// Retour de la fonction
			return Retour;
		}
		
		//**********************************************************************
		// Cherche une image à afficher dans le dossier d'animeshell
		//**********************************************************************
		public void ImageSearch(Gtk.Image imgCover)
		{
			string sImage = "";
			
			// Searching an image with ID
			if (TreeviewSelect != "")
			{
				if (File.Exists(Dossier+TreeviewSelectID+".jpg"))
					sImage = TreeviewSelectID+".jpg";
				else
				{
					if (File.Exists(Dossier+TreeviewSelectID+".png"))
						sImage = TreeviewSelectID+".png";
					else
					{
						if (File.Exists(Dossier+TreeviewSelectID+".gif"))
							sImage = TreeviewSelectID+".gif";
						else
							sImage = "NoImage.png";
					}
				}
			}
			try
			{
				if (sImage == "NoImage.png")
					imgCover.Pixbuf = Pixbuf.LoadFromResource("NoImage.png");
				else
				{
					// Image object
					Pixbuf imgSelection = new Pixbuf(Dossier+sImage);
					// Loading image
					imgSelection = imgSelection.ScaleSimple(160, 240, InterpType.Hyper);
					imgCover.Pixbuf = imgSelection;
				}
					
			}
			catch (Exception EX)
			{
				MessageDialog md = new MessageDialog (null,DialogFlags.DestroyWithParent,
				                                         MessageType.Error,ButtonsType.Close,
				                                         "Une erreur s'est produite lors du chargement de pochette\n\r"+EX.ToString());
				md.Run();
				md.Destroy();
			}
			
		}
		
		//*******************************************************************
		// Fonction de recherche dans le fichier .db d'animeshell
		//*******************************************************************
		public void InternalSearch(string Nom)
		{
			string Affichage = "Résultat de la recherche\r\n==================\r\n\r\n";
			string Line = null;
			StreamReader sr = null;
			
			// Look if the name is alright
			if (Nom == "")
			{
				MessageDialog md = new MessageDialog (null,DialogFlags.DestroyWithParent,MessageType.Warning, 
			                                         ButtonsType.Close, "Veuillez remplir le champs pour la recherche");
				md.Run();
				md.Destroy();
				return;
			}
			
			// Search
			try
			{
				sr = new StreamReader(Conf);
				Nom = Nom.ToLower();
				while ((Line = sr.ReadLine()) != null)
				{
					if (Line.ToLower().IndexOf(Nom) != -1)
					{
						Affichage += Line + "\r\nDVD No: "+sr.ReadLine()+"\r\n\r\n";
					}
				}
				
				// MessageDialog
				MessageDialog mdResult = new MessageDialog (null,DialogFlags.DestroyWithParent,MessageType.Info, 
			                                         ButtonsType.Close, Affichage);
				mdResult.Run();
				mdResult.Destroy();
			}
			catch(Exception EX)
			{
				MessageDialog mdError = new MessageDialog (null,DialogFlags.DestroyWithParent,MessageType.Error, 
				                                              ButtonsType.Close,
				                                        "Une erreur s'est produite lors de la recherche!\r\n"+EX.ToString());
				mdError.Run();
				mdError.Destroy();
			}
			finally
			{
				if (sr != null)
					sr.Close();
			}
		}
		
		//*******************************************************************
		// Fonction de recherche externe
		//*******************************************************************
		public void ExternalSearch(string A)
		{
			// Variable process et arguments préalables
			Process p = new Process();
			p.StartInfo.FileName = Pref[0];
			p.StartInfo.Arguments = A;
			
			// Démarrage!
			p.Start();
			p.Close();
			
		}
		
		//*******************************************************************
		// Chargement des préférences
		//*******************************************************************
		public void LoadRc()
		{
			// Variables
			StreamReader sr = null;
			string Line = null;
			
			// Chargement des préférences
			try
			{
				// Ouverture du fichier de configuration
				sr = new StreamReader(rc);
				// Chargement des préférences
				if ((Line = sr.ReadLine()) != null)
				{
					m_Pref[0] = Line;
					m_Pref[1] = sr.ReadLine();
				}
			}
			catch(Exception EX)
			{
				MessageDialog md = new MessageDialog (null,DialogFlags.DestroyWithParent,
				                        MessageType.Error,ButtonsType.Close,
				                        "Une erreur s'est produite lors du chargement de vos préférences\r\n"+EX.ToString());
				md.Run();
				md.Destroy();
			}
			finally
			{
				if (sr != null)
					sr.Close();
			}
		}
		
		//*******************************************************************
		// Ajout d'une entrée {ID, nom, type, # support}
		/*
		*
		* Lors d'une ajout complète, la deuxième fonction AjoutPartiel
		* est appellé pour compléter l'entrée
		*
		*/
		//*******************************************************************
		public bool AjoutComplet(string Nom, char Type, string No, string Comment)
		{
			// Variables
			bool Retour = false;
			
			// Traitement
			// Ajout à l'ArrayList
			// m_DonneArray.Add(new Entree(ID, Nom, cType, dvd, Commentaire));
			try
			{
				m_DonneArray.Add(new Entree(ID, Nom, Type, No, Comment));
				Retour = true;
			}
			catch
			{
				Retour = false;
			}
			
			// Retour de la fonction
			return Retour;
		}
		
		//*******************************************************************
		// Ajout partiel d'une entrée {Image, commentaire}
		//*******************************************************************
		public bool AjoutPartiel(string Image, string Comment)
		{
			// Variables
			bool Retour = false;
			
			// Traitement
			
			
			// Retour de la fonction
			return Retour;
		}
		
		//*******************************************************************
		// Fonction de copie de l'image
		//*******************************************************************
		public bool CopyImage(string Img)
		{
			// Variables
			bool Retour = false;
			
			// Traitement
			try
			{
				File.Copy(Img, Dossier+ID+(System.IO.Path.GetExtension(Img)));
				Retour = true;
			}
			catch
			{
				Retour = false;
			}
			
			// Retour de la fonction
			return Retour;
		}
	}
}





















	
